Impara Java in 10 minuti

9 July 2025 — Linguaggio Di Programmazione

Java è un linguaggio di programmazione orientato agli oggetti di alto livello noto per il suo principio “scrivi una volta, esegui ovunque”. Questo tutorial copre le funzionalità di Java 21+, aiutandoti a imparare rapidamente i fondamenti di Java.

1. Scrivere il tuo primo programma Java

I programmi Java sono organizzati in classi. Iniziamo con un programma semplice. Crea un file chiamato HelloWorld.java:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Compila ed esegui il programma:

javac HelloWorld.java
java HelloWorld

L’output sarà:

Hello, World!

Questo semplice programma dimostra la struttura di base di Java. Ogni programma Java deve avere almeno una classe, e il metodo main è il punto di ingresso.

2. Sintassi di base

La sintassi Java è strutturata e segue regole specifiche:

// Questo è un commento a riga singola
/* Questo è un
   commento multi-riga */

public class BasicSyntax {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

Regole di sintassi di base in Java:

Sensibilità alle maiuscole: Java è sensibile alle maiuscole. Variable e variable sono diversi.
Nomi delle classi: Devono iniziare con una lettera maiuscola e seguire la convenzione CamelCase.
Nomi dei metodi: Devono iniziare con una lettera minuscola e seguire la convenzione camelCase.
Punti e virgola: Ogni istruzione deve terminare con un punto e virgola ;.
Parentesi graffe: I blocchi di codice sono definiti usando parentesi graffe {}.
Commenti: I commenti a riga singola usano //, i commenti multi-riga usano /* */.

3. Variabili e tipi di dati

Java è un linguaggio tipizzato staticamente, il che significa che devi dichiarare esplicitamente i tipi di variabili.

Regole di nomenclatura delle variabili:

Devono iniziare con una lettera, underscore _, o simbolo del dollaro $.
Possono contenere lettere, cifre, underscore e simboli del dollaro.
Non possono essere parole chiave Java.
Dovrebbero seguire la convenzione camelCase.

Tipi di dati primitivi di Java:

byte: intero con segno a 8 bit (-128 a 127)
short: intero con segno a 16 bit (-32,768 a 32,767)
int: intero con segno a 32 bit (-2^31 a 2^31-1)
long: intero con segno a 64 bit (-2^63 a 2^63-1)
float: virgola mobile a 32 bit
double: virgola mobile a 64 bit
boolean: true o false
char: carattere Unicode a 16 bit

public class DataTypes {
    public static void main(String[] args) {
        // Tipi interi
        byte age = 25;
        short year = 2024;
        int population = 1000000;
        long distance = 93000000L; // suffisso L per long
        
        // Tipi a virgola mobile
        float temperature = 36.5f; // suffisso f per float
        double pi = 3.14159265359;
        
        // Booleano e carattere
        boolean isActive = true;
        char grade = 'A';
        
        // Stringa (tipo di riferimento)
        String name = "Alice";
        
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

3.1 Operazioni sulle stringhe

Le stringhe in Java sono oggetti, non tipi primitivi:

public class StringExample {
    public static void main(String[] args) {
        String text = "Java Programming";
        
        System.out.println("Length: " + text.length());
        System.out.println("Uppercase: " + text.toUpperCase());
        System.out.println("Lowercase: " + text.toLowerCase());
        System.out.println("Character at index 0: " + text.charAt(0));
        System.out.println("Substring: " + text.substring(0, 4));
        System.out.println("Contains 'Java': " + text.contains("Java"));
        
        // Concatenazione di stringhe
        String greeting = "Hello, " + "World!";
        System.out.println(greeting);
        
        // Formattazione di stringhe
        String formatted = String.format("Pi is approximately %.2f", 3.14159);
        System.out.println(formatted);
    }
}

4. Array e collezioni

4.1 Array

Gli array memorizzano più valori dello stesso tipo:

public class ArrayExample {
    public static void main(String[] args) {
        // Dichiarazione e inizializzazione dell'array
        int[] numbers = {1, 2, 3, 4, 5};
        String[] fruits = new String[3];
        fruits[0] = "apple";
        fruits[1] = "banana";
        fruits[2] = "orange";
        
        // Accesso agli elementi dell'array
        System.out.println("First number: " + numbers[0]);
        System.out.println("Array length: " + numbers.length);
        
        // Iterazione attraverso gli array
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Number " + i + ": " + numbers[i]);
        }
        
        // Ciclo for migliorato (for-each)
        for (String fruit : fruits) {
            System.out.println("Fruit: " + fruit);
        }
        
        // Array multidimensionali
        int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
        System.out.println("Matrix element [1][1]: " + matrix[1][1]);
    }
}

4.2 Collezioni

Il Java Collections Framework fornisce strutture dati dinamiche:

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // ArrayList (array dinamico)
        ArrayList<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.remove("Bob");
        System.out.println("Names: " + names);
        
        // HashMap (coppie chiave-valore)
        HashMap<String, Integer> ages = new HashMap<>();
        ages.put("Alice", 25);
        ages.put("Bob", 30);
        ages.put("Charlie", 35);
        System.out.println("Alice's age: " + ages.get("Alice"));
        
        // HashSet (elementi unici)
        HashSet<Integer> uniqueNumbers = new HashSet<>();
        uniqueNumbers.add(1);
        uniqueNumbers.add(2);
        uniqueNumbers.add(2); // Duplicato, non sarà aggiunto
        uniqueNumbers.add(3);
        System.out.println("Unique numbers: " + uniqueNumbers);
        
        // Iterazione attraverso le collezioni
        for (String name : names) {
            System.out.println("Name: " + name);
        }
        
        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

5. Operazioni e operatori

Java fornisce vari operatori per diverse operazioni:

Operatori aritmetici: +, -, *, /, % (modulo), ++ (incremento), -- (decremento)
Operatori di confronto: ==, !=, >, <, >=, <=
Operatori logici: && (e), || (o), ! (non)
Operatori bitwise: &, |, ^, ~, <<, >>, >>>
Operatori di assegnazione: =, +=, -=, *=, /=, %=

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10, b = 3;
        
        // Operazioni aritmetiche
        System.out.println("Addition: " + (a + b));
        System.out.println("Subtraction: " + (a - b));
        System.out.println("Multiplication: " + (a * b));
        System.out.println("Division: " + (a / b));
        System.out.println("Modulus: " + (a % b));
        
        // Incremento e decremento
        System.out.println("Pre-increment: " + (++a));
        System.out.println("Post-decrement: " + (b--));
        
        // Operazioni di confronto
        System.out.println("Equal: " + (a == b));
        System.out.println("Not equal: " + (a != b));
        System.out.println("Greater than: " + (a > b));
        
        // Operazioni logiche
        boolean x = true, y = false;
        System.out.println("AND: " + (x && y));
        System.out.println("OR: " + (x || y));
        System.out.println("NOT: " + (!x));
        
        // Operazioni di assegnazione
        int c = 5;
        c += 3; // c = c + 3
        System.out.println("After += 3: " + c);
    }
}

6. Flusso di controllo

6.1 Istruzioni condizionali

public class ConditionalExample {
    public static void main(String[] args) {
        int score = 85;
        
        // istruzione if-else
        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else if (score >= 70) {
            System.out.println("Grade: C");
        } else {
            System.out.println("Grade: F");
        }
        
        // Operatore ternario
        String result = (score >= 60) ? "Pass" : "Fail";
        System.out.println("Result: " + result);
        
        // istruzione switch
        char grade = 'B';
        switch (grade) {
            case 'A':
                System.out.println("Excellent!");
                break;
            case 'B':
                System.out.println("Good!");
                break;
            case 'C':
                System.out.println("Average");
                break;
            default:
                System.out.println("Invalid grade");
        }
    }
}

6.2 Cicli

public class LoopExample {
    public static void main(String[] args) {
        // ciclo for
        System.out.println("For loop:");
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteration: " + i);
        }
        
        // Ciclo for migliorato (for-each)
        System.out.println("\nFor-each loop:");
        int[] numbers = {1, 2, 3, 4, 5};
        for (int num : numbers) {
            System.out.println("Number: " + num);
        }
        
        // ciclo while
        System.out.println("\nWhile loop:");
        int count = 0;
        while (count < 3) {
            System.out.println("Count: " + count);
            count++;
        }
        
        // ciclo do-while
        System.out.println("\nDo-while loop:");
        int x = 0;
        do {
            System.out.println("X: " + x);
            x++;
        } while (x < 3);
        
        // break e continue
        System.out.println("\nBreak and continue:");
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break; // Esce dal ciclo
            }
            if (i % 2 == 0) {
                continue; // Salta i numeri pari
            }
            System.out.println("Odd number: " + i);
        }
    }
}

7. Metodi (funzioni)

I metodi in Java sono funzioni che appartengono alle classi:

public class MethodExample {
    
    // Metodo senza parametri e senza valore di ritorno
    public static void greet() {
        System.out.println("Hello, World!");
    }
    
    // Metodo con parametri e valore di ritorno
    public static int add(int a, int b) {
        return a + b;
    }
    
    // Metodo con parametri multipli
    public static String formatName(String firstName, String lastName) {
        return firstName + " " + lastName;
    }
    
    // Overloading di metodi (stesso nome, parametri diversi)
    public static int multiply(int a, int b) {
        return a * b;
    }
    
    public static double multiply(double a, double b) {
        return a * b;
    }
    
    // Argomenti variabili (varargs)
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    public static void main(String[] args) {
        greet();
        
        int result = add(5, 3);
        System.out.println("Addition result: " + result);
        
        String fullName = formatName("John", "Doe");
        System.out.println("Full name: " + fullName);
        
        System.out.println("Multiply integers: " + multiply(4, 5));
        System.out.println("Multiply doubles: " + multiply(2.5, 3.0));
        
        System.out.println("Sum of multiple numbers: " + sum(1, 2, 3, 4, 5));
    }
}

8. Programmazione orientata agli oggetti

8.1 Classi e oggetti

public class Person {
    // Variabili di istanza (campi)
    private String name;
    private int age;
    private String email;
    
    // Costruttore
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    
    // Costruttore di default
    public Person() {
        this("Unknown", 0, "");
    }
    
    // Metodi getter
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public String getEmail() {
        return email;
    }
    
    // Metodi setter
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        }
    }
    
    public void setEmail(String email) {
        this.email = email;
    }
    
    // Metodo di istanza
    public void introduce() {
        System.out.println("Hi, I'm " + name + ", " + age + " years old.");
    }
    
    // Metodo con logica
    public boolean isAdult() {
        return age >= 18;
    }
    
    // Metodo toString (sovrascrive il toString di Object)
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", email='" + email + "'}";
    }
    
    public static void main(String[] args) {
        // Creazione di oggetti
        Person person1 = new Person("Alice", 25, "[email protected]");
        Person person2 = new Person();
        
        // Utilizzo dei metodi
        person1.introduce();
        System.out.println("Is adult: " + person1.isAdult());
        
        person2.setName("Bob");
        person2.setAge(17);
        person2.setEmail("[email protected]");
        
        System.out.println(person1.toString());
        System.out.println(person2.toString());
    }
}

Questo tutorial Java completo copre i concetti essenziali necessari per iniziare con la programmazione Java. La tipizzazione forte del linguaggio, le funzionalità orientate agli oggetti e l’ampia libreria standard lo rendono potente per costruire applicazioni robuste. Pratica questi esempi e sperimenta con il codice per approfondire la tua comprensione dei concetti di programmazione Java.